{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "cifar-classifier.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "metadata": {
        "id": "5XHBpCexS5BU",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Imports"
      ]
    },
    {
      "metadata": {
        "id": "z0DRPKl39290",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pickle\n",
        "import os\n",
        "import urllib\n",
        "import zipfile \n",
        "import tarfile\n",
        "from six.moves import urllib\n",
        "\n",
        "from __future__ import absolute_import\n",
        "from __future__ import division\n",
        "from __future__ import print_function\n",
        "\n",
        "# tensorflow imports\n",
        "import tensorflow as tf\n",
        "from tensorflow.contrib.training import HParams\n",
        "\n",
        "# tf.keras imports\n",
        "from tensorflow.keras import Model\n",
        "from tensorflow.keras.layers import Dense, Conv2D, Activation, Flatten\n",
        "from tensorflow.keras.layers import BatchNormalization, AveragePooling2D, Input\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "# import for showing the confusion matrix\n",
        "import itertools\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "EJJ9RthRS9Fv",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Define hyperparameters for training"
      ]
    },
    {
      "metadata": {
        "id": "KZtezQ4qD-lU",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "hparams = HParams(\n",
        "    n_classes=10,  # number of different classes in dataset\n",
        "    learning_rate=1e-4,  # fixed learning rate\n",
        "    train_batch_size=32,  # training batch size\n",
        "    val_batch_size=32,  # validation batch size\n",
        "    test_batch_size=32,  # testing batch size\n",
        "    n_epochs=10,  # number of epochs to train\n",
        "    input_name='input_1',  # name of the input tensor for first layer of Keras model\n",
        "    data_dir='/tmp/cifar-data/',  # path to data directory\n",
        "    checkpoint_dir='/tmp/checkpoints/'  # path to model checkpoint directory\n",
        ")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "BsL72f44TA3I",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Monitor training using TensorBoard"
      ]
    },
    {
      "metadata": {
        "id": "BXSBbyK1FyBh",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "First, let's download and install the awesome tool [ngrok](https://ngrok.com/). Ngrok allows us to create a public URL to access the localhost of the ipython environment within Google Colab. This allows us to access the TensorBoard within the browser of your local machine."
      ]
    },
    {
      "metadata": {
        "id": "L35DdtT_FOXP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "outputId": "4dcc06f2-f7ec-4075-e3e6-3509d425c461"
      },
      "cell_type": "code",
      "source": [
        "! wget https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip\n",
        "! unzip -o ngrok-stable-linux-amd64.zip"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2018-11-06 09:42:38--  https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip\n",
            "Resolving bin.equinox.io (bin.equinox.io)... 52.45.111.123, 52.45.248.161, 52.4.75.11, ...\n",
            "Connecting to bin.equinox.io (bin.equinox.io)|52.45.111.123|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 5363700 (5.1M) [application/octet-stream]\n",
            "Saving to: ‘ngrok-stable-linux-amd64.zip’\n",
            "\n",
            "ngrok-stable-linux- 100%[===================>]   5.11M  3.48MB/s    in 1.5s    \n",
            "\n",
            "2018-11-06 09:42:40 (3.48 MB/s) - ‘ngrok-stable-linux-amd64.zip’ saved [5363700/5363700]\n",
            "\n",
            "Archive:  ngrok-stable-linux-amd64.zip\n",
            "  inflating: ngrok                   \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "EB5P9HvKEblD",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Now, we run `ngrok` in the `ipython` environment and tunnel the data to a public random URL using ngrok."
      ]
    },
    {
      "metadata": {
        "id": "YwZrIjZkEEYu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "96bbcf36-0b90-4a74-f496-28b97633526c"
      },
      "cell_type": "code",
      "source": [
        "# kill all running ngrok instances\n",
        "!pkill -f ngrok\n",
        "\n",
        "# Execute tensorboard\n",
        "!rm rf /tmp/checkpoints\n",
        "!mkdir /tmp/checkpoints\n",
        "LOG_DIR = '/tmp/checkpoints/'\n",
        "get_ipython().system_raw(\n",
        "    'tensorboard --logdir {} --host 0.0.0.0 --port 6006 &'\n",
        "    .format(LOG_DIR)\n",
        ")\n",
        "\n",
        "# execute ngrok\n",
        "get_ipython().system_raw('./ngrok http 6006 &')"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "rm: cannot remove 'rf': No such file or directory\n",
            "rm: cannot remove '/tmp/checkpoints': No such file or directory\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "gkCnSnAREdny",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "The below code should output a URL containg the TensorBoard visualizations for the classifier we are about to train and evaluate."
      ]
    },
    {
      "metadata": {
        "id": "3Imio4YREFzg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "43e662b1-c728-477f-9dc0-5b48e1860ebd"
      },
      "cell_type": "code",
      "source": [
        "# Do the tunneling\n",
        "! curl -s http://localhost:4040/api/tunnels | python3 -c \\\n",
        "    \"import sys, json; print(json.load(sys.stdin)['tunnels'][0]['public_url'])\""
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "http://e7e35edb.ngrok.io\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "0KqmhIDXTKK7",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Data download and preprocessing"
      ]
    },
    {
      "metadata": {
        "id": "VuC2mMKOIIRJ",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "This code is boilerplate code for downloading and preprocessing of the CIFAR-10 dataset. Credits to [Hvass-Labs](https://github.com/Hvass-Labs/TensorFlow-Tutorials/blob/master/cifar10.py)."
      ]
    },
    {
      "metadata": {
        "id": "2EpQ-iJN94G1",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# URL for the data-set on the internet.\n",
        "data_url = \"https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\"\n",
        "\n",
        "# Width and height of each image.\n",
        "img_size = 32\n",
        "\n",
        "# Number of channels in each image, 3 channels: Red, Green, Blue.\n",
        "num_channels = 3\n",
        "\n",
        "# Length of an image when flattened to a 1-dim array.\n",
        "img_size_flat = img_size * img_size * num_channels\n",
        "\n",
        "# Number of classes.\n",
        "num_classes = hparams.n_classes\n",
        "\n",
        "########################################################################\n",
        "# Various constants used to allocate arrays of the correct size.\n",
        "\n",
        "# Number of files for the training-set.\n",
        "_num_files_train = 5\n",
        "\n",
        "# Number of images for each batch-file in the training-set.\n",
        "_images_per_file = 10000\n",
        "\n",
        "# Total number of images in the training-set.\n",
        "# This is used to pre-allocate arrays for efficiency.\n",
        "_num_images_train = _num_files_train * _images_per_file\n",
        "\n",
        "########################################################################\n",
        "# Private functions for downloading, unpacking and loading data-files.\n",
        "\n",
        "\n",
        "def download(base_url, filename, download_dir):\n",
        "    \"\"\"\n",
        "    Download the given file if it does not already exist in the download_dir.\n",
        "    :param base_url: The internet URL without the filename.\n",
        "    :param filename: The filename that will be added to the base_url.\n",
        "    :param download_dir: Local directory for storing the file.\n",
        "    :return: Nothing.\n",
        "    \"\"\"\n",
        "\n",
        "    # Path for local file.\n",
        "    save_path = os.path.join(download_dir, filename)\n",
        "\n",
        "    # Check if the file already exists, otherwise we need to download it now.\n",
        "    if not os.path.exists(save_path):\n",
        "        # Check if the download directory exists, otherwise create it.\n",
        "        if not os.path.exists(download_dir):\n",
        "            os.makedirs(download_dir)\n",
        "\n",
        "        print(\"Downloading\", filename, \"...\")\n",
        "\n",
        "        # Download the file from the internet.\n",
        "        url = base_url + filename\n",
        "        file_path, _ = urllib.request.urlretrieve(url=url,\n",
        "                                                  filename=save_path)\n",
        "\n",
        "        print(\" Done!\")\n",
        "\n",
        "\n",
        "def maybe_download_and_extract(url=data_url, download_dir=hparams.data_dir):\n",
        "    \"\"\"\n",
        "    Download and extract the data if it doesn't already exist.\n",
        "    Assumes the url is a tar-ball file.\n",
        "    :param url:\n",
        "        Internet URL for the tar-file to download.\n",
        "        Example: \"https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\"\n",
        "    :param download_dir:\n",
        "        Directory where the downloaded file is saved.\n",
        "        Example: \"data/CIFAR-10/\"\n",
        "    :return:\n",
        "        Nothing.\n",
        "    \"\"\"\n",
        "\n",
        "    # Filename for saving the file downloaded from the internet.\n",
        "    # Use the filename from the URL and add it to the download_dir.\n",
        "    filename = url.split('/')[-1]\n",
        "    file_path = os.path.join(download_dir, filename)\n",
        "\n",
        "    # Check if the file already exists.\n",
        "    # If it exists then we assume it has also been extracted,\n",
        "    # otherwise we need to download and extract it now.\n",
        "    if not os.path.exists(file_path):\n",
        "        # Check if the download directory exists, otherwise create it.\n",
        "        if not os.path.exists(download_dir):\n",
        "            os.makedirs(download_dir)\n",
        "\n",
        "        # Download the file from the internet.\n",
        "        file_path, _ = urllib.request.urlretrieve(url=url,\n",
        "                                                  filename=file_path)\n",
        "\n",
        "        print()\n",
        "        print(\"Download finished. Extracting files.\")\n",
        "\n",
        "        if file_path.endswith(\".zip\"):\n",
        "            # Unpack the zip-file.\n",
        "            zipfile.ZipFile(file=file_path, mode=\"r\").extractall(download_dir)\n",
        "        elif file_path.endswith((\".tar.gz\", \".tgz\")):\n",
        "            # Unpack the tar-ball.\n",
        "            tarfile.open(name=file_path, mode=\"r:gz\").extractall(download_dir)\n",
        "\n",
        "        print(\"Done.\")\n",
        "    else:\n",
        "        print(\"Data has apparently already been downloaded and unpacked.\")\n",
        "\n",
        "\n",
        "def _get_file_path(filename=\"\"):\n",
        "    \"\"\"\n",
        "    Return the full path of a data-file for the data-set.\n",
        "\n",
        "    If filename==\"\" then return the directory of the files.\n",
        "    \"\"\"\n",
        "\n",
        "    return os.path.join(hparams.data_dir, \"cifar-10-batches-py/\", filename)\n",
        "\n",
        "\n",
        "def _unpickle(filename):\n",
        "    \"\"\"\n",
        "    Unpickle the given file and return the data.\n",
        "\n",
        "    Note that the appropriate dir-name is prepended the filename.\n",
        "    \"\"\"\n",
        "\n",
        "    # Create full path for the file.\n",
        "    file_path = _get_file_path(filename)\n",
        "\n",
        "    print(\"Loading data: \" + file_path)\n",
        "\n",
        "    with open(file_path, mode='rb') as file:\n",
        "        # In Python 3.X it is important to set the encoding,\n",
        "        # otherwise an exception is raised here.\n",
        "        data = pickle.load(file,encoding='bytes')\n",
        "\n",
        "    return data\n",
        "\n",
        "\n",
        "def _convert_images(raw):\n",
        "    \"\"\"\n",
        "    Convert images from the CIFAR-10 format and\n",
        "    return a 4-dim array with shape: [image_number, height, width, channel]\n",
        "    where the pixels are floats between 0.0 and 1.0.\n",
        "    \"\"\"\n",
        "\n",
        "    # Convert the raw images from the data-files to floating-points.\n",
        "    raw_float = np.array(raw, dtype=float) / 255.0\n",
        "\n",
        "    # Reshape the array to 4-dimensions.\n",
        "    images = raw_float.reshape([-1, num_channels, img_size, img_size])\n",
        "\n",
        "    # Reorder the indices of the array.\n",
        "    images = images.transpose([0, 2, 3, 1])\n",
        "\n",
        "    return images\n",
        "\n",
        "\n",
        "def _load_data(filename):\n",
        "    \"\"\"\n",
        "    Load a pickled data-file from the CIFAR-10 data-set\n",
        "    and return the converted images (see above) and the class-number\n",
        "    for each image.\n",
        "    \"\"\"\n",
        "\n",
        "    # Load the pickled data-file.\n",
        "    data = _unpickle(filename)\n",
        "\n",
        "    # Get the raw images.\n",
        "    raw_images = data[b'data']\n",
        "\n",
        "    # Get the class-numbers for each image. Convert to numpy-array.\n",
        "    cls = np.array(data[b'labels'])\n",
        "\n",
        "    # Convert the images.\n",
        "    images = _convert_images(raw_images)\n",
        "\n",
        "    return images, cls\n",
        "\n",
        "\n",
        "def load_class_names():\n",
        "    # Load the class-names from the pickled file.\n",
        "    raw = _unpickle(filename=\"batches.meta\")[b'label_names']\n",
        "\n",
        "    # Convert from binary strings.\n",
        "    names = [x.decode('utf-8') for x in raw]\n",
        "\n",
        "    return names\n",
        "\n",
        "\n",
        "def load_training_data():\n",
        "    \"\"\"\n",
        "    Load all the training-data for the CIFAR-10 data-set.\n",
        "\n",
        "    The data-set is split into 5 data-files which are merged here.\n",
        "\n",
        "    Returns the images, class-numbers and one-hot encoded class-labels.\n",
        "    \"\"\"\n",
        "\n",
        "    # Pre-allocate the arrays for the images and class-numbers for efficiency.\n",
        "    images = np.zeros(shape=[_num_images_train, img_size, img_size, num_channels], dtype=float)\n",
        "    cls = np.zeros(shape=[_num_images_train], dtype=int)\n",
        "\n",
        "    # Begin-index for the current batch.\n",
        "    begin = 0\n",
        "\n",
        "    # For each data-file.\n",
        "    for i in range(_num_files_train):\n",
        "        # Load the images and class-numbers from the data-file.\n",
        "        images_batch, cls_batch = _load_data(filename=\"data_batch_\" + str(i + 1))\n",
        "\n",
        "        # Number of images in this batch.\n",
        "        num_images = len(images_batch)\n",
        "\n",
        "        # End-index for the current batch.\n",
        "        end = begin + num_images\n",
        "\n",
        "        # Store the images into the array.\n",
        "        images[begin:end, :] = images_batch\n",
        "\n",
        "        # Store the class-numbers into the array.\n",
        "        cls[begin:end] = cls_batch\n",
        "\n",
        "        # The begin-index for the next batch is the current end-index.\n",
        "        begin = end\n",
        "\n",
        "    return images, cls\n",
        "\n",
        "\n",
        "def load_validation_data():\n",
        "\n",
        "    images, cls = _load_data(filename=\"test_batch\")\n",
        "\n",
        "    images = images[5000:, :, :, :]\n",
        "    cls = cls[5000:]\n",
        "\n",
        "    return images, cls\n",
        "\n",
        "def load_testing_data():\n",
        "\n",
        "\n",
        "    images, cls = _load_data(filename=\"test_batch\")\n",
        "\n",
        "    images = images[:5000, :, :, :]\n",
        "    cls = cls[:5000]\n",
        "\n",
        "    return images, cls"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "eiCehG29Urjk",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Network architecture\n",
        "\n",
        "The below code defines the architecture of the neural network we are going to train. We will be using the infamous Resnet architecture with Shortcut connections and bottlenecs. The paper may be found [here](https://www.cv-foundation.org/openaccess/content_cvpr_2016/papers/He_Deep_Residual_Learning_CVPR_2016_paper.pdf).\n",
        "\n",
        "We will be using the `tensorflow.keras` API - TensorFlow's implementation of the Keras API specification. This is a high-level API to build and train models that includes first-class support for TensorFlow-specific functionality. Keras is able to use TensorFlow as its backend for tensor processing during training and inference, making Keras easy-to-use but also just as fast as pure TensorFlow models.\n",
        "\n",
        "The model code is part of the Keras examples and may be found [here](https://github.com/keras-team/keras/blob/master/examples/cifar10_resnet.py)."
      ]
    },
    {
      "metadata": {
        "id": "9mj6sUIhU009",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def resnet_layer(inputs,\n",
        "                 num_filters=16,\n",
        "                 kernel_size=3,\n",
        "                 strides=1,\n",
        "                 activation='relu',\n",
        "                 batch_normalization=True,\n",
        "                 conv_first=True):\n",
        "    \"\"\"2D Convolution-Batch Normalization-Activation stack builder\n",
        "    # Arguments\n",
        "        inputs (tensor): input tensor from input image or previous layer\n",
        "        num_filters (int): Conv2D number of filters\n",
        "        kernel_size (int): Conv2D square kernel dimensions\n",
        "        strides (int): Conv2D square stride dimensions\n",
        "        activation (string): activation name\n",
        "        batch_normalization (bool): whether to include batch normalization\n",
        "        conv_first (bool): conv-bn-activation (True) or\n",
        "            bn-activation-conv (False)\n",
        "    # Returns\n",
        "        x (tensor): tensor as input to the next layer\n",
        "    \"\"\"\n",
        "    conv = Conv2D(num_filters,\n",
        "                  kernel_size=kernel_size,\n",
        "                  strides=strides,\n",
        "                  padding='same',\n",
        "                  kernel_initializer='he_normal',\n",
        "                  kernel_regularizer=tf.keras.regularizers.l2(1e-4))\n",
        "\n",
        "    x = inputs\n",
        "    if conv_first:\n",
        "        x = conv(x)\n",
        "        if batch_normalization:\n",
        "            x = BatchNormalization()(x)\n",
        "        if activation is not None:\n",
        "            x = Activation(activation)(x)\n",
        "    else:\n",
        "        if batch_normalization:\n",
        "            x = BatchNormalization()(x)\n",
        "        if activation is not None:\n",
        "            x = Activation(activation)(x)\n",
        "        x = conv(x)\n",
        "    return x\n",
        "\n",
        "\n",
        "def resnet_v2(input_shape, depth=20, num_classes=10):\n",
        "    \"\"\"ResNet Version 2 Model builder [b]\n",
        "    Stacks of (1 x 1)-(3 x 3)-(1 x 1) BN-ReLU-Conv2D or also known as\n",
        "    bottleneck layer\n",
        "    First shortcut connection per layer is 1 x 1 Conv2D.\n",
        "    Second and onwards shortcut connection is identity.\n",
        "    At the beginning of each stage, the feature map size is halved (downsampled)\n",
        "    by a convolutional layer with strides=2, while the number of filter maps is\n",
        "    doubled. Within each stage, the layers have the same number filters and the\n",
        "    same filter map sizes.\n",
        "    Features maps sizes:\n",
        "    conv1  : 32x32,  16\n",
        "    stage 0: 32x32,  64\n",
        "    stage 1: 16x16, 128\n",
        "    stage 2:  8x8,  256\n",
        "    # Arguments\n",
        "        input_shape (tensor): shape of input image tensor\n",
        "        depth (int): number of core convolutional layers\n",
        "        num_classes (int): number of classes (CIFAR10 has 10)\n",
        "    # Returns\n",
        "        model (Model): Keras model instance\n",
        "    \"\"\"\n",
        "    if (depth - 2) % 9 != 0:\n",
        "        raise ValueError('depth should be 9n+2 (eg 56 or 110 in [b])')\n",
        "    # Start model definition.\n",
        "    num_filters_in = 16\n",
        "    num_res_blocks = int((depth - 2) / 9)\n",
        "\n",
        "    inputs = Input(shape=input_shape)\n",
        "    # v2 performs Conv2D with BN-ReLU on input before splitting into 2 paths\n",
        "    x = resnet_layer(inputs=inputs,\n",
        "                     num_filters=num_filters_in,\n",
        "                     conv_first=True)\n",
        "\n",
        "    # Instantiate the stack of residual units\n",
        "    for stage in range(3):\n",
        "        for res_block in range(num_res_blocks):\n",
        "            activation = 'relu'\n",
        "            batch_normalization = True\n",
        "            strides = 1\n",
        "            if stage == 0:\n",
        "                num_filters_out = num_filters_in * 4\n",
        "                if res_block == 0:  # first layer and first stage\n",
        "                    activation = None\n",
        "                    batch_normalization = False\n",
        "            else:\n",
        "                num_filters_out = num_filters_in * 2\n",
        "                if res_block == 0:  # first layer but not first stage\n",
        "                    strides = 2    # downsample\n",
        "\n",
        "            # bottleneck residual unit\n",
        "            y = resnet_layer(inputs=x,\n",
        "                             num_filters=num_filters_in,\n",
        "                             kernel_size=1,\n",
        "                             strides=strides,\n",
        "                             activation=activation,\n",
        "                             batch_normalization=batch_normalization,\n",
        "                             conv_first=False)\n",
        "            y = resnet_layer(inputs=y,\n",
        "                             num_filters=num_filters_in,\n",
        "                             conv_first=False)\n",
        "            y = resnet_layer(inputs=y,\n",
        "                             num_filters=num_filters_out,\n",
        "                             kernel_size=1,\n",
        "                             conv_first=False)\n",
        "            if res_block == 0:\n",
        "                # linear projection residual shortcut connection to match\n",
        "                # changed dims\n",
        "                x = resnet_layer(inputs=x,\n",
        "                                 num_filters=num_filters_out,\n",
        "                                 kernel_size=1,\n",
        "                                 strides=strides,\n",
        "                                 activation=None,\n",
        "                                 batch_normalization=False)\n",
        "            x = tf.keras.layers.add([x, y])\n",
        "\n",
        "        num_filters_in = num_filters_out\n",
        "\n",
        "    # Add classifier on top.\n",
        "    # v2 has BN-ReLU before Pooling\n",
        "    x = BatchNormalization()(x)\n",
        "    x = Activation('relu')(x)\n",
        "    x = AveragePooling2D(pool_size=8)(x)\n",
        "    y = Flatten()(x)\n",
        "    outputs = Dense(num_classes,\n",
        "                    activation='softmax',\n",
        "                    kernel_initializer='he_normal')(y)\n",
        "\n",
        "    # Instantiate model.\n",
        "    model = Model(inputs=inputs, outputs=outputs)\n",
        "\n",
        "    model.compile(loss='sparse_categorical_crossentropy',\n",
        "                  optimizer=tf.keras.optimizers.Adam(lr=hparams.learning_rate),\n",
        "                  metrics=['accuracy'])\n",
        "\n",
        "    return model"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "BfGrJgWdVVg3",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Fit the classifier\n"
      ]
    },
    {
      "metadata": {
        "id": "zxfLg369ZTKo",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "In the below code, we first load the training, validation, and testing data. Then we define a Keras ImageDataGenerator which performs on-the-fly augmentation of the training images in order to increase the number of training samples and thus reduces the risk of overfitting the training data set.\n",
        "\n",
        "The actual classifier training happens in line 46 with the command `resnet_model.fit_generator(...)`."
      ]
    },
    {
      "metadata": {
        "id": "VQWJ-urr99OC",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 544
        },
        "outputId": "6cbf938d-5d88-4784-bab6-42d989796cf8"
      },
      "cell_type": "code",
      "source": [
        "tf.logging.set_verbosity(tf.logging.DEBUG)\n",
        "\n",
        "resnet_model = resnet_v2((32, 32, 3), depth=56, num_classes=hparams.n_classes)\n",
        "\n",
        "# Download and extract CIFAR-10 data\n",
        "maybe_download_and_extract()\n",
        "\n",
        "# training data\n",
        "x_train, y_train = load_training_data()\n",
        "\n",
        "# Validation data\n",
        "x_val, y_val = load_validation_data()\n",
        "\n",
        "# Testing data\n",
        "x_test, y_test = load_testing_data()\n",
        "\n",
        "# Define callbacks\n",
        "callbacks = [\n",
        "  tf.keras.callbacks.TensorBoard(log_dir=hparams.checkpoint_dir)\n",
        "]\n",
        "\n",
        "# This will do preprocessing and realtime data augmentation:\n",
        "datagen = ImageDataGenerator(\n",
        "    featurewise_center=False,  # set input mean to 0 over the dataset\n",
        "    samplewise_center=False,  # set each sample mean to 0\n",
        "    featurewise_std_normalization=False,  # divide inputs by std of the dataset\n",
        "    samplewise_std_normalization=False,  # divide each input by its std\n",
        "    zca_whitening=False,  # apply ZCA whitening\n",
        "    zca_epsilon=1e-06,  # epsilon for ZCA whitening\n",
        "    rotation_range=0,  # randomly rotate images in the range (degrees, 0 to 180)\n",
        "    # randomly shift images horizontally (fraction of total width)\n",
        "    width_shift_range=0.1,\n",
        "    # randomly shift images vertically (fraction of total height)\n",
        "    height_shift_range=0.1,\n",
        "    # set mode for filling points outside the input boundaries\n",
        "    fill_mode='nearest',\n",
        "    cval=0.,  # value used for fill_mode = \"constant\"\n",
        "    horizontal_flip=True,  # randomly flip images\n",
        "    vertical_flip=False)\n",
        "\n",
        "# Compute quantities required for feature-wise normalization\n",
        "# (std, mean, and principal components if ZCA whitening is applied).\n",
        "datagen.fit(x_train)\n",
        "\n",
        "# Fit the model on the batches generated by datagen.flow().\n",
        "resnet_model.fit_generator(\n",
        "    datagen.flow(x_train, y_train,batch_size=hparams.train_batch_size),\n",
        "    epochs=hparams.n_epochs,\n",
        "    validation_data=(x_val, y_val),\n",
        "    workers=4,\n",
        "    callbacks=callbacks)\n",
        "\n"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Download finished. Extracting files.\n",
            "Done.\n",
            "Loading data: /tmp/cifar-data/cifar-10-batches-py/data_batch_1\n",
            "Loading data: /tmp/cifar-data/cifar-10-batches-py/data_batch_2\n",
            "Loading data: /tmp/cifar-data/cifar-10-batches-py/data_batch_3\n",
            "Loading data: /tmp/cifar-data/cifar-10-batches-py/data_batch_4\n",
            "Loading data: /tmp/cifar-data/cifar-10-batches-py/data_batch_5\n",
            "Loading data: /tmp/cifar-data/cifar-10-batches-py/test_batch\n",
            "Loading data: /tmp/cifar-data/cifar-10-batches-py/test_batch\n",
            "Epoch 1/10\n",
            "1563/1563 [==============================] - 438s 280ms/step - loss: 2.6938 - acc: 0.4096 - val_loss: 2.4192 - val_acc: 0.4886\n",
            "Epoch 2/10\n",
            "1563/1563 [==============================] - 424s 271ms/step - loss: 2.2846 - acc: 0.5250 - val_loss: 2.1631 - val_acc: 0.5570\n",
            "Epoch 3/10\n",
            "1563/1563 [==============================] - 424s 271ms/step - loss: 2.0919 - acc: 0.5748 - val_loss: 2.0243 - val_acc: 0.5942\n",
            "Epoch 4/10\n",
            "1563/1563 [==============================] - 424s 272ms/step - loss: 1.9521 - acc: 0.6125 - val_loss: 2.0059 - val_acc: 0.5780\n",
            "Epoch 5/10\n",
            "1563/1563 [==============================] - 424s 271ms/step - loss: 1.8456 - acc: 0.6376 - val_loss: 1.7581 - val_acc: 0.6610\n",
            "Epoch 6/10\n",
            "1563/1563 [==============================] - 422s 270ms/step - loss: 1.7572 - acc: 0.6624 - val_loss: 1.7489 - val_acc: 0.6616\n",
            "Epoch 7/10\n",
            "1563/1563 [==============================] - 425s 272ms/step - loss: 1.6818 - acc: 0.6818 - val_loss: 1.6522 - val_acc: 0.6938\n",
            "Epoch 8/10\n",
            "1563/1563 [==============================] - 426s 272ms/step - loss: 1.6117 - acc: 0.7008 - val_loss: 1.6403 - val_acc: 0.6838\n",
            "Epoch 9/10\n",
            "1563/1563 [==============================] - 424s 272ms/step - loss: 1.5525 - acc: 0.7159 - val_loss: 1.6752 - val_acc: 0.6826\n",
            "Epoch 10/10\n",
            "1563/1563 [==============================] - 411s 263ms/step - loss: 1.4963 - acc: 0.7321 - val_loss: 1.4956 - val_acc: 0.7286\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tensorflow.python.keras.callbacks.History at 0x7f3e269a36a0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "metadata": {
        "id": "QG-vhJ14RkBy",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Visualization of confusion matrix\n",
        "\n",
        "The below code takes a confusion matrix and produces a nice and shiny visualization"
      ]
    },
    {
      "metadata": {
        "id": "UiKRYOWPfhJs",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "def plot_confusion_matrix(cm, classes,\n",
        "                          normalize=False,\n",
        "                          title='Confusion matrix',\n",
        "                          cmap=plt.cm.Blues):\n",
        "    \"\"\"\n",
        "    This function prints and plots the confusion matrix.\n",
        "    Normalization can be applied by setting `normalize=True`.\n",
        "    \"\"\"\n",
        "    if normalize:\n",
        "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
        "        print(\"Normalized confusion matrix\")\n",
        "    else:\n",
        "        print('Confusion matrix, without normalization')\n",
        "\n",
        "    print(cm)\n",
        "\n",
        "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
        "    plt.title(title)\n",
        "    plt.colorbar()\n",
        "    tick_marks = np.arange(len(classes))\n",
        "    plt.xticks(tick_marks, classes, rotation=45)\n",
        "    plt.yticks(tick_marks, classes)\n",
        "\n",
        "    fmt = '.2f' if normalize else 'd'\n",
        "    thresh = cm.max() / 2.\n",
        "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
        "        plt.text(j, i, format(cm[i, j], fmt),\n",
        "                 horizontalalignment=\"center\",\n",
        "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
        "\n",
        "    plt.ylabel('True label')\n",
        "    plt.xlabel('Predicted label')\n",
        "    plt.tight_layout()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "BqY-vngiRoTZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 588
        },
        "outputId": "3a40248b-09d0-44b4-ec96-c1d14eb8b152"
      },
      "cell_type": "code",
      "source": [
        "results = resnet_model.predict(x_test, batch_size=hparams.test_batch_size)\n",
        "\n",
        "# convert from class probabilities to actual class predictions\n",
        "predicted_classes = np.argmax(results, axis=1)\n",
        "\n",
        "# Names of predicted classes\n",
        "class_names = [\"airplane\", \"automobile\", \"bird\", \"cat\", \"deer\", \"dog\", \"frog\", \"horse\", \"ship\", \"truck\"]\n",
        "\n",
        "# Generate the confusion matrix\n",
        "cnf_matrix = confusion_matrix(y_test, predicted_classes)\n",
        "\n",
        "# Plot non-normalized confusion matrix\n",
        "plt.figure()\n",
        "plot_confusion_matrix(cnf_matrix, classes=class_names,\n",
        "                      title='Confusion matrix, without normalization')\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Confusion matrix, without normalization\n",
            "[[382   7  17   6   2   1   5   5  58   5]\n",
            " [  6 449   1   4   0   3   1   1  32   8]\n",
            " [ 53   1 318  31  26  23  28  17  12   3]\n",
            " [ 15   1  41 273  13  87  24  18  20   5]\n",
            " [ 14   5  44  33 286  20  45  52   8   0]\n",
            " [ 10   2  27  70   7 329  13  21   9   0]\n",
            " [  9   1  32  39  14  10 372   2  11   1]\n",
            " [ 16   3  19  16   7  24   2 400   7   1]\n",
            " [ 15   6   4   0   1   0   2   1 473   2]\n",
            " [ 32  59   9   6   1   3   3   9  48 343]]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAboAAAGACAYAAADbFqdOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n87HRAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<matplotlib.figure.Figure at 0x7f3e191ec630>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    }
  ]
}
